home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / tie / src / move.c < prev    next >
C/C++ Source or Header  |  1991-10-18  |  45KB  |  1,655 lines
  1. /*
  2.  *  TMENU.INF Editor    アイテム移動画面
  3. */
  4.  
  5. #include "config.h"
  6. #include "edit.h"
  7.  
  8. #define MAX_DSP 25      /*  一度に画面に表示できる数  */
  9. #define item_x(x)   (((x)%5)*ITEM_X_SIZ+ITEM_X)
  10. #define item_y(y)   (((y)/5)*ITEM_Y_SIZ+ITEM_Y)
  11.  
  12. #define DISP_NUM    /*  アイテムの番号を表示する場合は定義する  */
  13. #undef  DISP_NUM
  14.  
  15. #define MV_START    0
  16. #define MV_RESTART  1
  17. #define MV_LOOP     2
  18. #define MV_END      3
  19.  
  20. INFO    info[MULTI_BUF] ;
  21. int     active_buf = 0 ;
  22.  
  23. ICON    icon[ 128 ] ;
  24. INF     inf[ MAX_INF ] ;        /*  現在編集中のデータ  */
  25. INF     org_inf[ MAX_INF ] ;    /*  ロードしたときのデータ  */
  26. int     org_maxnum ;            /*  ロードしたときの最大数  */
  27.  
  28. int     load_count = 0 ;    /*  TMENU.INF をロードした回数  */
  29. int     maxnum = 0 ;
  30.  
  31. int     mos_disp = MOS_OFF ;
  32. int     menu_event = 0 ;
  33. int     now_palet = 0 ;
  34. int     writepage = PAGE0 ;
  35.  
  36. static  INF     tmpinf = { 0 } ;
  37. static  char    mark[ MAX_INF ] ;
  38. static  int     vol_size = 0 ;
  39. static  int     pos = 0 ;
  40. static  int     marknum = 0 ;
  41. static  int     item_move = -1 ;
  42. static  int     item_copy = -1 ;
  43.  
  44. static  char    *func_btn[ MAX_FUNC ] =
  45.                  { " 移 動 ", " 交 換 ", " 削 除 ", " 編 集 ", " 複 写 " } ;
  46. static  int     func = -1 ;
  47.  
  48. static  CDBUF   wild_inf[ CARD_MAX ] =
  49. {
  50.     { OFF,FALSE,"*.*" }, { ON ,FALSE,"*.INF" }, { OFF,FALSE,"*.BAK" },
  51.     { OFF,TRUE, NULL  }, { OFF,TRUE,  NULL   }, { OFF,TRUE,  NULL   },
  52.     { OFF,TRUE, NULL  }, { OFF,TRUE,  NULL   }, { OFF,TRUE,  NULL   },
  53.     { OFF,TRUE, NULL  },
  54. } ;
  55.  
  56. static  CDBUF   wild_new[ CARD_MAX ] =
  57. {
  58.     { OFF,FALSE,"*.*"   }, { ON, FALSE,"*.EXP" }, { ON, FALSE,"*.EXE" },
  59.     { ON, FALSE,"*.COM" }, { ON, FALSE,"*.BAT" }, { OFF,TRUE,  NULL   },
  60.     { OFF,TRUE, NULL    }, { OFF,TRUE,  NULL   }, { OFF,TRUE,  NULL   },
  61.     { OFF,TRUE, NULL    },
  62. } ;
  63.  
  64. static  char    tmp[ 256 ] ;
  65.  
  66.  
  67. extern  char    *select_file( char *def_file, char cmd ) ;
  68. extern  void    click_item( int item ) ;
  69. extern  void    move( int func, int x, int y ) ;
  70. extern  void    clear_mark( void ) ;
  71. extern  int     del_item( void ) ;
  72. extern  void    del_inf( int i ) ;
  73. extern  void    ins_inf( int i ) ;
  74. extern  void    dsp_scrn( int, int ) ;
  75. extern  void    dsp_scrn( int, int ) ;
  76. extern  void    dsp_item( int, INF *, int ) ;
  77. extern  void    dsp_bar( int num ) ;
  78. extern  void    dsp_func_btn( void ) ;
  79. extern  void    dsp_func( int num ) ;
  80. extern  void    dsp_mark( int num, int sw ) ;
  81. extern  void    dsp_menu( char *file ) ;
  82. extern  int     readinf( char * ) ;
  83. extern  int     writeinf( char * ) ;
  84. extern  void    item_recover( int redisplayflag ) ;
  85. extern  void    item_rewrite( int, int, int ) ;
  86. extern  void    chg_mark( int ) ;
  87. extern  void    unset_mark( int ) ;
  88. extern  void    set_mark( int ) ;
  89. extern  void    MENU_clip( REGS EVENT *ep, int x, int y, int sw ) ;
  90. extern  void    MOVE_clip( REGS EVENT *ep, int x, int y, int sw ) ;
  91. extern  void    ITEM_clip( REGS EVENT *ep, int x, int y, int sw ) ;
  92.  
  93. void    toupper_inf( INF *ip )
  94. {
  95.     REGS    int     i ;
  96.     auto    char    type[256] ;
  97.  
  98.     typecheck( type, (char *)ip->fname, IR_FNAMLEN ) ;
  99.     for( i = 0 ; i < IR_FNAMLEN ; i ++ )
  100.         if( type[i] == IS_ANK )
  101.             ip->fname[i] = toupper( ip->fname[i] ) ;
  102.  
  103.     typecheck( type, (char *)ip->fext, IR_FEXTLEN ) ;
  104.     for( i = 0 ; i < IR_FEXTLEN ; i ++ )
  105.         if( type[i] == IS_ANK )
  106.             ip->fext[i] = toupper( ip->fext[i] ) ;
  107.  
  108.     typecheck( type, (char *)ip->cmd, IR_CMDLEN ) ;
  109.     for( i = 0 ;
  110.              i < IR_CMDLEN && ip->cmd[i] != '\0' && ip->cmd[i] != ' ' ; i ++ )
  111.         if( type[i] == IS_ANK )
  112.             ip->cmd[i] = toupper( ip->cmd[i] ) ;
  113.     if( ( i = strlen( ip->cmd ) ) < IR_CMDLEN-1 )
  114.         ip->cmd[i] = ' ', ip->cmd[i+1] = '\0' ;
  115. }
  116.  
  117. int     sep_dirmode( char *file )
  118. {
  119.     int     len = strlen( file ) ;
  120.  
  121.     if( file[len-1] == 0x10 )       /*  dir  */
  122.     {
  123.         file[len-1] = '\0' ;
  124.         return 0x10 ;
  125.     }
  126.     else
  127.         return 0 ;
  128. }
  129.  
  130. void    init_file_buf( int max )
  131. {
  132.     int     i ;
  133.  
  134.     for( i = 0 ; i < max ; i ++ )
  135.     {
  136.         info[i].pathlist[0] = '\0' ;
  137.         info[i].maxnum = 0 ;
  138.         info[i].org_maxnum = 0 ;
  139.         memcpy( &info[i].icon, &icon, sizeof( icon ) ) ;
  140.     }
  141. }
  142.  
  143. char    *change_buf( char *file )
  144. {
  145.     INFO    *ip ;
  146.  
  147.     load_count ++ ;     /*  TMENU.ICN が切り替わったことを明示  */
  148.  
  149.     /*  現在のデータを退避  */
  150.     ip = &info[ active_buf ] ;
  151.  
  152.     strcpy( ip->pathlist, file ) ;
  153.     memcpy( ip->icon, icon, sizeof( icon ) ) ;
  154.     ip->maxnum = maxnum ;
  155.     memcpy( ip->inf, inf, sizeof( inf ) ) ;
  156.     ip->org_maxnum = org_maxnum ;
  157.     memcpy( ip->org_inf, org_inf, sizeof( inf ) ) ;
  158.  
  159.     /*  切り換え  */
  160.     if( ( ++ active_buf ) >= MULTI_BUF )
  161.         active_buf = 0 ;
  162.  
  163.     /*  復帰  */
  164.     ip = &info[ active_buf ] ;
  165.  
  166.     memcpy( icon, ip->icon, sizeof( icon ) ) ;
  167.     maxnum = ip->maxnum ;
  168.     memcpy( inf, ip->inf, sizeof( inf ) ) ;
  169.     org_maxnum = ip->org_maxnum ;
  170.     memcpy( org_inf, ip->org_inf, sizeof( inf ) ) ;
  171.  
  172.     return ip->pathlist ;
  173. }
  174.  
  175. char    *select_file( char *def_file, char cmd )
  176. {
  177.     auto    int     sw, mos_x, mos_y ;
  178.     auto    int     mos = mos_disp ;
  179.     auto    char    *ret_file, *msg ;
  180.     auto    int     dirflag ;
  181.  
  182.     MOS_PAD_rdpos( &sw, &mos_x, &mos_y ) ;
  183.  
  184.     if( now_palet != 1 )
  185.         chg_palette( 0, 1 ) ;
  186.     switch( cmd )
  187.     {
  188.       case 'N': msg = "新規登録する実行ファイルを選択してください" ;
  189.         dirflag = ON ;
  190.         break ;
  191.       case 'L': msg = "読み込むアイテムファイルを選択してください" ;
  192.         dirflag = OFF ;
  193.         break ;
  194.       case 'S': msg = "書き込むアイテムファイルを指定してください" ;
  195.         dirflag = OFF ;
  196.         break ;
  197.     }
  198.     ret_file = file_select( def_file, msg,
  199.             ( cmd == 'N' ) ? wild_new : wild_inf, dirflag ) ;
  200.     MOS_disp( MOS_OFF ) ;
  201.  
  202.     cls( 1, 0 ) ;
  203.     DSP_writePage( egbwork, 0 ) ;
  204.  
  205.     MOS_writePage( 0 ) ;
  206.     MOS_horizon ( MIN_HORIZON,  MAX_HORIZON ) ;
  207.     MOS_vertical( MIN_VERTICAL, MAX_VERTICAL ) ;
  208.  
  209.     MOS_setpos( mos_x, mos_y ) ;
  210.     MOS_disp( mos ) ;
  211.  
  212.     chg_palette( 0, now_palet ) ;
  213.  
  214.     return( ret_file ) ;
  215. }
  216.  
  217. /*
  218.  *  ファイルをロードする
  219.  *
  220.  
  221.  *  戻り値  まともに読めた場合      -> パス名へのポインタ
  222.  *          キャンセルした場合      -> NULL ポインタ
  223.  *          読んだけど失敗した場合  -> 長さ0の文字列
  224. */
  225.  
  226. char    *load_file( void )
  227. {
  228.     auto    char    *file = NULL ;
  229.     static  char    buf[ 256 ] ;
  230.  
  231.     chg_palette( 0, now_palet = 1 ) ;
  232.  
  233.     file = select_file( NULL, 'L' ) ;
  234.  
  235.     if( file != NULL )
  236.     {
  237.         switch( readinf( file ) )   /*  ロードを実行  */
  238.         {
  239.           case ERR_ABORT:   /*  回復不能  */
  240.             *file = '\0' ;
  241.             break ;
  242.  
  243.           case ERR_BREAK:   /*  回復可能  */
  244.             file = NULL ;
  245.             break ;
  246.  
  247.           case ERR_NOERROR: /*  エラーなし  */
  248.             strcpy( buf, file ) ;
  249.             file = buf ;
  250.             break ;
  251.         }
  252.     }
  253.  
  254.     chg_palette( 0, now_palet = 0 ) ;
  255.     KAN_dispMode() ;        /*  モード再表示  */
  256.  
  257.     return( file ) ;
  258. }
  259.  
  260.  
  261. /*
  262.  *  ファイルをセーブする
  263.  *
  264.  
  265.  *  パラメータ  現在のファイル
  266.  
  267.  *  戻り値  まともに書けた場合      -> 書いたファイル名
  268.  *          キャンセルした場合      -> NULL
  269.  *          書き込みに失敗した場合  -> NULL
  270. */
  271.  
  272. char    *save_file( char *file )
  273. {
  274.     auto    char    filename[ 256 ] ;
  275.     auto    int     pal = now_palet ;
  276.  
  277.     chg_palette( 0, now_palet = 1 ) ;
  278.  
  279.     file = select_file( file, 'S' ) ;
  280.  
  281.     if( file == NULL || *file == '\0' )
  282.     {
  283.         chg_palette( 0, now_palet = pal ) ;
  284.         KAN_dispMode() ;        /*  モード再表示  */
  285.         return( NULL ) ;
  286.     }
  287.     strcpy( filename, file ) ;
  288.  
  289.     if( writeinf( filename ) == ERROR )     /*  書き込みに失敗した  */
  290.     {
  291.         chg_palette( 0, now_palet = pal ) ;
  292.         KAN_dispMode() ;        /*  モード再表示  */
  293.         return( NULL ) ;
  294.     }
  295.  
  296.     chg_palette( 0, now_palet = pal ) ;
  297.     KAN_dispMode() ;        /*  モード再表示  */
  298.  
  299.     return( filename ) ;
  300. }
  301.  
  302.  
  303. /*  アイテム移動画面のメイン処理部  */
  304.  
  305.  
  306. int     edit_move( char file[] )
  307. {
  308.     int     num = 0, rewrite = TRUE ;
  309.     int     ret_val = RET_DEFAULT ;
  310.     int     ch = 0 ;
  311.     char    *tmpfile ;
  312.  
  313.     if( func == -1 )            /*  起動時のデフォルト・ファンクション  */
  314.         func = setup.func ;
  315.  
  316.     MOS_disp( mos_disp = FALSE ) ;
  317.  
  318.     EVT_reset() ;
  319.     dsp_menu( file ) ;      /*  一番上の行などなど  */
  320.  
  321.     MOS_disp( mos_disp = TRUE ) ;
  322.  
  323.     do
  324.     {
  325.         dsp_scrn( num, rewrite ) ;
  326.         rewrite = FALSE ;
  327.  
  328.         do
  329.         {
  330.             menu_event = 0 ;
  331.  
  332.             EVT_loop( 0,3 ) ;
  333.  
  334.             if( kbhit( OFF ) != FALSE )       /*  キー入力センス  */
  335.             {
  336.                 switch( ch = getch() )
  337.                 {
  338.                   case 0x807C:      /*  BREAK : 読み込み  */
  339.                     menu_event = 15 ;   break ;
  340.                   case 0x807D:      /*  COPY : 新規  */
  341.                     menu_event = 4 ;    break ;
  342.  
  343.                   case 0x805D:      /*  PF1 : 移動  */
  344.                     menu_event = 5 ;    break ;
  345.                   case 0x805E:      /*  PF2 : 交換  */
  346.                     menu_event = 6 ;    break ;
  347.                   case 0x805F:      /*  PF3 : 削除  */
  348.                     menu_event = 7 ;    break ;
  349.                   case 0x8060:      /*  PF4 : 編集  */
  350.                     menu_event = 8 ;    break ;
  351.                   case 0x8061:      /*  PF5 : 複写  */
  352.                     menu_event = 9 ;    break ;
  353.  
  354.                   case 0x8066:      /*  PF10 : 終了  */
  355.                     menu_event = 1 ;    break ;
  356.                   case 0x8069:      /*  PF11 : 読み込み  */
  357.                     menu_event = 2 ;    break ;
  358.                   case 0x805B:      /*  PF12 : 書き込み  */
  359.                     menu_event = 3 ;    break ;
  360.  
  361.                   case 0x806E:      /*  前行  */
  362.                     menu_event = 10 ;   break ;
  363.                   case 0x8070:      /*  次行  */
  364.                     menu_event = 11 ;   break ;
  365.  
  366.                   default:          /*  無視  */
  367.                     break ;
  368.                 }
  369.             }
  370.  
  371.             if( cancel_on != FALSE )        /*  キャンセル  */
  372.             {
  373.                 if( item_move != -1 || marknum > 0 || item_copy != -1 )
  374.                 {
  375.                     MOS_disp( mos_disp = FALSE ) ;
  376.  
  377.                     if( item_move != -1 )
  378.                         item_recover( TRUE ) ;
  379.                     item_copy = -1 ;
  380.                     move( MV_END, 0,0 ) ;
  381.                     clear_mark() ;          /*  マークを解除  */
  382.  
  383.                     MOS_disp( mos_disp = TRUE ) ;
  384.                 }
  385.  
  386.                 cancel_on = FALSE ;
  387.             }
  388.  
  389.             switch( menu_event )
  390.             {
  391.               case 1:                       /*  終了  */
  392.                 if( end_assert( file ) == TRUE )
  393.                     ret_val = RET_QUIT ;
  394.                 else
  395.                 {
  396.                     menu_event = 0 ;
  397.                     title( file ) ;
  398.                 }
  399.                 break ;
  400.  
  401.               case 2:                       /*  読み込み  */
  402.                 if( ( tmpfile = load_file() ) == NULL )
  403.                     menu_event = 0 ;
  404.                 else
  405.                 {
  406.                     if( *tmpfile == '\0' )
  407.                         maxnum = 0 ;
  408.                     strcpy( file, tmpfile ) ;
  409.                     rewrite = TRUE ;
  410.                     num = pos = 0 ;
  411.                     title( file ) ;
  412.                 }
  413.                 break ;
  414.  
  415.               case 3:                       /*  書き込み  */
  416.                 if( item_move != -1 )
  417.                     item_recover( TRUE ) ;
  418.                 if( ( tmpfile = save_file( file ) ) == NULL )
  419.                     menu_event = 0 ;
  420.                 else
  421.                 {
  422.                     strcpy( file, tmpfile ) ;
  423.                     title( file ) ;
  424.                 }
  425.                 break ;
  426.  
  427.               case 4:                       /*  新規  */
  428.                 if( ( tmpfile = select_file( NULL, 'N' ) ) == NULL )
  429.                     menu_event = 0 ;
  430.                 else
  431.                 {
  432.                     int     dirmode = 0 ;
  433.  
  434.                     dirmode = sep_dirmode( tmpfile ) ;
  435.                     init_inf( &inf[maxnum], tmpfile, NULL,-1 ) ;
  436.                     inf[maxnum].dirflag = dirmode ;
  437.                     mark[maxnum] = FALSE ;
  438.  
  439.                     if( edit_item( &inf[maxnum] ) == FALSE )   /*  中止  */
  440.                         menu_event = 0 ;
  441.                     else
  442.                     {
  443.                         maxnum ++ ;
  444.                         rewrite = TRUE ;
  445.                     }
  446.                 }
  447.                 break ;
  448.  
  449.               case 5:                       /*  移動  */
  450.                 if( func != FUNC_MOVE )
  451.                     dsp_func( func ), dsp_func( func = FUNC_MOVE ) ;
  452.  
  453.                 if( marknum > 0 )
  454.                     clear_mark() ;
  455.                 menu_event = 0 ;
  456.                 break ;
  457.  
  458.               case 6:                       /*  交換  */
  459.                 if( func != FUNC_CHG )
  460.                     dsp_func( func ), dsp_func( func = FUNC_CHG ) ;
  461.  
  462.                 if( marknum > 0 )
  463.                     clear_mark() ;
  464.                 if( item_move != -1 )
  465.                     item_recover( TRUE ) ;
  466.                 if( item_copy != -1 )
  467.                     item_copy = -1 ;
  468.                 menu_event = 0 ;
  469.                 break ;
  470.  
  471.               case 7:                       /*  削除  */
  472.                 /*  機能を削除にする  */
  473.                 if( func != FUNC_DEL )
  474.                     dsp_func( func ), dsp_func( func = FUNC_DEL ) ;
  475.  
  476.                 menu_event = 0 ;
  477.  
  478.                 if( item_copy != -1 )
  479.                     item_copy = -1 ;
  480.                 if( marknum != 0 || item_move != -1 )
  481.                 {               /*  マークされているものを削除  */
  482.                     if( item_move != -1 )   /*  移動中のものは元に戻す  */
  483.                     {
  484.                         int num = item_move ;
  485.                         item_recover( TRUE ) ;
  486.                         chg_mark( num ) ;
  487.                     }
  488.                     del_item() ;
  489.                 }
  490.                 break ;
  491.  
  492.               case 8:                       /*  編集  */
  493.                 if( func != FUNC_EDIT )
  494.                     dsp_func( func ), dsp_func( func = FUNC_EDIT ) ;
  495.  
  496.                 if( marknum > 0 )
  497.                     clear_mark() ;
  498.                 if( item_move != -1 )
  499.                     item_recover( TRUE ) ;
  500.                 if( item_copy != -1 )
  501.                     item_copy = -1 ;
  502.                 menu_event = 0 ;
  503.                 break ;
  504.  
  505.               case 9:                       /*  複写  */
  506.                 if( func != FUNC_COPY )
  507.                     dsp_func( func ), dsp_func( func = FUNC_COPY ) ;
  508.  
  509.                 if( marknum > 0 )
  510.                     clear_mark() ;
  511.                 if( item_move != -1 )
  512.                     item_recover( TRUE ) ;
  513.                 menu_event = 0 ;
  514.                 break ;
  515.  
  516.               case 10:                      /*  ↑  */
  517.                 num = pos - 5 ;
  518.                 break ;
  519.  
  520.               case 11:                      /*  ↓  */
  521.                 num = pos + 5 ;
  522.                 break ;
  523.  
  524.               case 12:                      /*  バッファの切り換え  */
  525. /*                if( item_move != -1 )
  526.                     item_recover( FALSE ) ; */
  527.                 if( marknum > 0 )
  528.                     clear_mark() ;
  529.  
  530.                 if( ( tmpfile = change_buf( file ) ) != NULL )
  531.                 {
  532.                     strcpy( file, tmpfile ) ;
  533.                     title( file ) ;
  534.                     rewrite = TRUE ;
  535.                 }
  536.                 break ;
  537.  
  538.               case 15:                      /*  編集モードへの切り換え  */
  539.                 if( item_move != -1 )       /*  移動中  */
  540.                     item_recover( TRUE ) ;
  541.                 ret_val = RET_MODE ;
  542.                 break ;
  543.  
  544.               case 100:                     /*  再表示  */
  545.                 num = pos ;
  546.                 rewrite = TRUE ;
  547.                 break ;
  548.  
  549.               default:
  550.                 if( menu_event >= 20 && menu_event < 20+MAX_DSP )
  551.                 {
  552.                     click_item( menu_event - 20 ) ;
  553.                     menu_event = 0 ;
  554.                 }
  555.             }
  556.  
  557.         } while( menu_event == 0 ) ;
  558.  
  559.     } while( ret_val == RET_DEFAULT ) ;
  560.  
  561.     return( ret_val ) ;
  562. }
  563.  
  564. void    unset_mark( int num )
  565. {
  566.     marknum -- ;
  567.     mark[ num ] = FALSE ;
  568. }
  569. void    set_mark( int num )
  570. {
  571.     marknum ++ ;
  572.     mark[ num ] = TRUE ;
  573. }
  574.  
  575. void    chg_mark( int num )
  576. {
  577.     if( mark[ num ] == TRUE )       /*  マークされているので解除  */
  578.         unset_mark( num ) ;
  579.     else
  580.         set_mark( num ) ;
  581.  
  582.     MOS_disp( FALSE ) ;
  583.     dsp_mark( num-pos, mark[ num ] ) ;
  584.     MOS_disp( mos_disp ) ;
  585. }
  586.  
  587. void    clear_mark( void )
  588. {
  589.     int     i ;
  590.  
  591.     if( marknum > 0 )       /*  マークを解除  */
  592.     {
  593.         MOS_disp( FALSE ) ;
  594.  
  595.         for( i = 0 ; i < MAX_DSP ; i ++ )
  596.             if( mark[ i+pos ] == TRUE )
  597.                 dsp_mark( i, FALSE ) ;
  598.  
  599.         marknum = 0 ;
  600.  
  601.         for( i = 0 ; i < maxnum ; i ++ )
  602.             mark[ i ] = FALSE ;
  603.  
  604.         MOS_disp( mos_disp ) ;
  605.     }
  606. }
  607.  
  608.  
  609. void    click_item( int item )
  610. {
  611.     static  int     last_mouse = 0, last_item = -1 ;
  612.     auto    int     now_mouse = 0 ;
  613.     auto    int     src, mos ;
  614.     auto    int     num = item + pos ;
  615.     auto    int     db = FALSE ;        /*  ダブルクリック  */
  616.  
  617.  
  618.     /*  ダブル・クリックの確認  */
  619.     now_mouse = MOS_getTime() ;
  620.     if( item == last_item && now_mouse <= last_mouse + 15 )
  621.         db = TRUE ;
  622.     last_mouse = now_mouse ;
  623.     last_item = item ;
  624.  
  625.     MOS_disp( mos_disp = MOS_OFF ) ;    /*  処理中は表示しない  */
  626.  
  627.     switch( func )
  628.     {
  629.     /*
  630.      *  『削除』
  631.     */
  632.  
  633.       case FUNC_DEL:
  634.         mos = TRUE ;       /*  終了後は表示  */
  635.  
  636.         if( num >= maxnum )    /*  無視  */
  637.             break ;
  638.  
  639.         if( db == TRUE )    /*  ダブルクリックならば、実行  */
  640.             del_item() ;
  641.         else                /*  普通のクリックならば、マークの反転  */
  642.             chg_mark( num ) ;
  643.  
  644.         break ;
  645.  
  646.  
  647.     /*
  648.      *  『編集』
  649.     */
  650.  
  651.       case FUNC_EDIT:
  652.         mos = TRUE ;       /*  終了後は表示  */
  653.  
  654.         if( num >= maxnum )    /*  無視  */
  655.             break ;
  656.  
  657.         /*  編集  */
  658.         if( edit_item( &inf[num] ) != FALSE )
  659.             dsp_item( item, &inf[num], TRUE ) ;
  660.  
  661.         break ;
  662.  
  663.  
  664.     /*
  665.      *  『移動』
  666.     */
  667.       case FUNC_MOVE:
  668.         mos = TRUE ;       /*  終了後は表示  */
  669.  
  670.         if( item_move != -1 )       /*  移動中である  */
  671.         {
  672.             item_move = -1 ;
  673.  
  674.             move( MV_END, 0,0 ) ;
  675.             MOS_disp( mos_disp = FALSE ) ;
  676.  
  677.             if( num >= maxnum )
  678.                 num = maxnum ;
  679.             ins_inf( num ) ;
  680.             inf[ num ] = tmpinf ;   /*  挿入  */
  681.         }
  682.         else                        /*  移動中ではない  */
  683.         {
  684.             if( num >= maxnum )     /*  無視  */
  685.                 break ;
  686.  
  687.             move( MV_START, item_x(item), item_y(item) ) ;
  688.  
  689.             tmpinf = inf[ num ] ;   /*  退避  */
  690.             del_inf( num ) ;        /*  コピー元を削除  */
  691.  
  692.             item_move = num ;
  693.             mos = FALSE ;      /*  終了後も表示しない  */
  694.         }
  695.  
  696.         item_rewrite( num, num+MAX_DSP, TRUE ) ;
  697.  
  698.         break ;
  699.  
  700.     /*
  701.      *  『交換』
  702.     */
  703.       case FUNC_CHG:
  704.         mos = TRUE ;       /*  終了後は表示  */
  705.  
  706.         if( num >= maxnum )     /*  無視  */
  707.             break ;
  708.  
  709.         if( marknum > 0 )       /*  交換先を探していた  */
  710.         {
  711.             move( MV_END, 0,0 ) ;
  712.             MOS_disp( FALSE ) ;
  713.  
  714.             if( mark[ num ] == TRUE )   /*  キャンセル  */
  715.             {
  716.                 unset_mark( num ) ;
  717.                 dsp_mark( item, mark[ num ] ) ;
  718.  
  719.                 break ;
  720.             }
  721.  
  722.             for( src = 0 ; src < maxnum ; src ++ )
  723.             {
  724.                 if( mark[ src ] == TRUE )     /*  コピー元  */
  725.                 {
  726.                     mark[ src ] = FALSE ;
  727.                     marknum -- ;
  728.  
  729.                     tmpinf = inf[ src ] ;     /*  交換  */
  730.                     inf[ src ] = inf[ num ] ;
  731.                     inf[ num ] = tmpinf ;
  732.  
  733.                     if( src >= pos && src < pos+MAX_DSP )
  734.                         item_rewrite( src, src, FALSE ) ;
  735.                     item_rewrite( num, num, FALSE ) ;
  736.  
  737.                     break ;
  738.                 }
  739.             }
  740.         }
  741.         else        /*  マークする  */
  742.         {
  743.             move( MV_START, item_x(item), item_y(item) ) ;
  744.  
  745.             chg_mark( num ) ;
  746.  
  747.             mos = FALSE ;      /*  終了後も表示しない  */
  748.         }
  749.         break ;
  750.  
  751.     /*
  752.      *  『複写』
  753.     */
  754.       case FUNC_COPY:
  755.         mos = TRUE ;       /*  終了後は表示  */
  756.  
  757.         if( item_copy != -1 )   /*  コピー先を探していた  */
  758.         {
  759.             item_copy = -1 ;
  760.  
  761.             move( MV_END, 0,0 ) ;
  762.             MOS_disp( mos_disp = FALSE ) ;
  763.  
  764.             if( num >= maxnum )
  765.                 num = maxnum ;
  766.             ins_inf( num ) ;
  767.             inf[ num ] = tmpinf ;   /*  挿入  */
  768.             mark[ num ] = FALSE ;
  769.  
  770.             item_rewrite( num, num+MAX_DSP, TRUE ) ;
  771.             dsp_bar( pos ) ;
  772.         }
  773.         else        /*  マークする  */
  774.         {
  775.             if( num >= maxnum )     /*  無視  */
  776.                 break ;
  777.  
  778.             move( MV_START, item_x(item), item_y(item) ) ;
  779.  
  780.             tmpinf = inf[ num ] ;   /*  バッファへコピー  */
  781.  
  782.             item_copy = num ;
  783.             mos = FALSE ;      /*  終了後も表示しない  */
  784.         }
  785.  
  786.         break ;
  787.     }
  788.  
  789.     MOS_disp( mos_disp = mos ) ;
  790. }
  791.  
  792. void    item_recover( int redisplayflag )
  793. {
  794.     ins_inf( item_move ) ;
  795.     inf[ item_move ] = tmpinf ;
  796.  
  797.     if( redisplayflag )
  798.     {
  799.         MOS_disp( MOS_OFF ) ;
  800.         item_rewrite( item_move, item_move+MAX_DSP, FALSE ) ;
  801.         MOS_disp( mos_disp ) ;
  802.     }
  803.     move( MV_END, 0,0 ) ;
  804.  
  805.     item_move = -1 ;
  806. }
  807.  
  808. /*
  809.  *  マークされているアイテムを削除する
  810.  
  811.  *  １つでも削除したら、ＴＲＵＥを返す
  812. */
  813.  
  814. int     del_item( void )
  815. {
  816.     int     i, ret ;
  817.  
  818.     if( marknum == 0 )      /*  マークなし  */
  819.         return( FALSE ) ;
  820.  
  821.     chg_palette( 0, now_palet = 1 ) ;
  822.  
  823.     msg[0] = "マークされたものを削除します" ;
  824.     msg[1] = "よろしいですか？" ;
  825.     msg[2] = NULL ;
  826.  
  827.     if( select_mode( msg_kakunin, msg, msg_btn2 ) == 0 )
  828.     {
  829.         /*  削除  */
  830.         for( i = 0 ; i < maxnum ; i ++ )
  831.             if( mark[i] == TRUE )
  832.             {
  833.                 del_inf( i ) ;
  834.                 i -- ;
  835.             }
  836.         marknum = 0 ;
  837.  
  838.         /*  画面書換え  */
  839.         dsp_scrn( pos, TRUE ) ;
  840.         ret = TRUE ;
  841.     }
  842.     else
  843.         ret = FALSE ;
  844.  
  845.     chg_palette( 0, now_palet = 0 ) ;
  846.  
  847.     return ret ;
  848. }
  849.  
  850. void    del_inf( int i )
  851. {
  852.     REGS    int     j ;
  853.  
  854.     for( j = i + 1 ; j < maxnum ; j ++ )
  855.     {
  856.         inf[ j-1 ] = inf[ j ] ;
  857.         mark[ j-1 ] = mark[ j ] ;
  858.     }
  859.     maxnum -- ;
  860. }
  861.  
  862. static  void    ins_inf( int i )
  863. {
  864.     REGS    int     j ;
  865.  
  866.     for( j = maxnum + 1 ; j > i ; j -- )
  867.     {
  868.         inf[ j ] = inf[ j-1 ] ;
  869.         mark[ j ] = mark[ j-1 ] ;
  870.     }
  871.     maxnum ++ ;
  872. }
  873.  
  874. void    title( char *name )
  875. {
  876.     int     len ;
  877.     char    buf[48] ;
  878.  
  879.     if( name == NULL || ( len = strlen( name ) ) < 1 )
  880.     {
  881.         sprintf( tmp,"<<< TMENU.INF EDITOR : TIE  %s %s >>>",
  882.                                                         VERSION, DATE ) ;
  883.     }
  884.     else
  885.     {
  886.         name = strncpy( buf, name, 34 ) ;
  887.         name[34] = '\0' ;
  888.         sprintf( tmp, "<< TIE %s >>   %-34s", VERSION, name ) ;
  889.     }
  890.  
  891.     wrt( tmp, writepage, 48,1, COL_1,COL_7, 16 ) ;
  892. }
  893.  
  894. static  void    dsp_func( int num )
  895. {
  896.     int     x = FN_X, xs = FNSIZX ;
  897.     int     y = FN_Y, ys = FNSIZY ;
  898.  
  899.     MOS_disp( FALSE ) ;
  900.  
  901.     EGB_writeMode( egbwork, 4 ) ;
  902.     x += xs * num ;
  903.     dsp_box( x+1,y+1, x+xs-1,y+ys-1, 15,15,15 ) ;
  904.     EGB_writeMode( egbwork, 0 ) ;
  905.  
  906.     MOS_disp( mos_disp ) ;
  907. }
  908.  
  909. static  void    dsp_func_btn( void )
  910. {
  911.     int     x = FN_X, xs = FNSIZX ;
  912.     int     y = FN_Y, ys = FNSIZY ;
  913.     int     i ;
  914.  
  915.     MOS_disp( FALSE ) ;
  916.  
  917.     dsp_box( x+2,y+2, x+xs*MAX_FUNC+2,y+ys+2, 1,1,1 ) ;
  918.  
  919.     for( i = 0 ; i < MAX_FUNC ; i ++ )
  920.     {
  921.         dsp_box( x,y, x+xs,y+ys, 1,1,15 ) ;
  922.         wrt( func_btn[i], writepage, x+6,y+2, COL_1,COL_15,16 ) ;
  923.         EVT_set_node( x,y, x+xs,y+ys, 1,MENU_clip,5+i, OFF ) ;
  924.         x += xs ;
  925.     }
  926.  
  927.     MOS_disp( mos_disp ) ;
  928. }
  929.  
  930. #define NEW_X   40          /*  [新規]ボタンの位置  */
  931. #define NEW_Y   (TOP_Y)
  932. #define LD_X    (549-38)
  933. #define LD_Y    (18)
  934. #define SV_X    (LD_X+BSIZ_X2)
  935. #define SV_Y    (18)
  936. #define CH_X    (LD_X)
  937. #define CH_Y    (3)
  938.  
  939. void    dsp_menu2( char *file, void (*menu)(), void (*move)() )
  940. {
  941.     dsp_box( SYS_X1,SYS_Y1, SYS_X2,SYS_Y2, 7,7,7 ) ;
  942.  
  943.     title( file ) ;
  944.  
  945.     dsp_box( NEW_X+2,NEW_Y+2, NEW_X+FNSIZX+2,NEW_Y+FNSIZY+2, 1,1,1 ) ;
  946.     dsp_box( NEW_X,NEW_Y, NEW_X+FNSIZX,NEW_Y+FNSIZY, 1,1,15 ) ;
  947.     wrt( " 新 規 ", writepage, NEW_X+6,NEW_Y+2, COL_1,COL_15,16 ) ;
  948.     EVT_set_node( NEW_X,NEW_Y, NEW_X+FNSIZX,NEW_Y+FNSIZY, 1,menu,4,OFF ) ;
  949.  
  950.     dsp_box( CH_X+2,CH_Y+2, CH_X+BSIZ_X2*2+2,CH_Y+14+2, 1,1,1 ) ;
  951.     dsp_box( CH_X,CH_Y, CH_X+BSIZ_X2*2,CH_Y+14, 1,1,15 ) ;
  952.     wrt( "切り換え", writepage, CH_X+10,CH_Y+4, COL_1, COL_15, 8 ) ;
  953.     EVT_set_node( CH_X,CH_Y, CH_X+BSIZ_X2*2,CH_Y+14, 1,menu,12, OFF ) ;
  954.  
  955.     dsp_box( LD_X+2,LD_Y+2, LD_X+BSIZ_X2+2,LD_Y+BSIZ_Y+2, 1,1,1 ) ;
  956.     dsp_box( LD_X,LD_Y, LD_X+BSIZ_X2,LD_Y+BSIZ_Y, 1,1,15 ) ;
  957.     wrt( " 読 ", writepage, LD_X+6,LD_Y+2, COL_1, COL_15, 16 ) ;
  958.     EVT_set_node( LD_X,LD_Y, LD_X+BSIZ_X2,LD_Y+BSIZ_Y, 1,menu,2, OFF ) ;
  959.  
  960.     dsp_box( SV_X+2,SV_Y+2, SV_X+BSIZ_X2+2,SV_Y+BSIZ_Y+2, 1,1,1 ) ;
  961.     dsp_box( SV_X,SV_Y, SV_X+BSIZ_X2,SV_Y+BSIZ_Y, 1,1,15 ) ;
  962.     wrt( " 書 ", writepage, SV_X+6,SV_Y+2, COL_1, COL_15, 16 ) ;
  963.     EVT_set_node( SV_X,SV_Y, SV_X+BSIZ_X2,SV_Y+BSIZ_Y, 1,menu,3, OFF ) ;
  964.  
  965.     dsp_box( MD_X+2,MD_Y+2, MD_X+35,MD_Y+35, 0,0,0 ) ;
  966.     dsp_box( MD_X,MD_Y, MD_X+33,MD_Y+33, 0,0,15 ) ; /*  画面切り替えボタン  */
  967.     EVT_set_node( MD_X,MD_Y,MD_X+33,MD_Y+33, 1, menu, 15, FALSE ) ;
  968.  
  969.     dsp_box( EX_X+2,EX_Y+2, EX_X+35,EX_Y+35, 0,0,0 ) ;
  970.     dsp_box( EX_X,EX_Y, EX_X+33,EX_Y+33, 0,0,15 ) ; /*  終了ボタン  */
  971.     dsp_ptn( EX_X+1,EX_Y+1, ptn_door, 0 ) ;
  972.     EVT_set_node( EX_X,EX_Y,EX_X+33,EX_Y+33, 1, menu, 1, FALSE ) ;
  973.  
  974.     dsp_box( UP_X, UP_Y, UP_X+19, UP_Y+19, 0,0,15 ) ;
  975.     wrt( "▲", writepage, UP_X+2, UP_Y+2, COL_0, COL_15, 16 ) ;
  976.     dsp_box( DW_X, DW_Y, DW_X+19, DW_Y+19, 0,0,15 ) ;
  977.     wrt( "▼", writepage, DW_X+2, DW_Y+2, COL_0, COL_15, 16 ) ;
  978.     EVT_set_node( UP_X,UP_Y,UP_X+19,UP_Y+19, 1,menu,10, TRUE ) ;
  979.     EVT_set_node( DW_X,DW_Y,DW_X+19,DW_Y+19, 1,menu,11, TRUE ) ;
  980.  
  981.     EVT_set_node( BAR_X,BAR_Y,BAR_X+19,BAR_Y+BAR_SIZ, 1,move,1, OFF ) ;
  982. }
  983.  
  984. static  void    dsp_menu( char *file )
  985. {
  986.     dsp_menu2( file, MENU_clip, MOVE_clip ) ;   /*  編集／移動 共通部分  */
  987.  
  988.     dsp_ptn( MD_X+1,MD_Y+1, ptn_move, 0 ) ;
  989.  
  990.     dsp_func_btn() ;        /*  機能ボタン一覧  */
  991.     dsp_func( func ) ;      /*  アクティブな機能ボタン  */
  992.  
  993.     /*  画面全体・キャンセル  */
  994.     EVT_set_node( SCR_X1,SCR_Y1, SCR_X2,SCR_Y2, 2, ITEM_clip, 1, FALSE ) ;
  995.     EVT_set_cancel( 1, click_cancel ) ;
  996. }
  997.  
  998. /*  アイコンを表示する  */
  999.  
  1000. static  void    dsp_scrn( int num, int rewrite )
  1001. {
  1002.     int     i, dif ;
  1003.     int     st, ed ;
  1004.     int     max = ( maxnum + 4 ) / 5 * 5 ;
  1005.     static  struct {
  1006.         short x1, y1, x2, y2 ;
  1007.     } para = { SCR_X1,SCR_Y1, SCR_X2,SCR_Y2 } ;
  1008.  
  1009.     if( num + MAX_DSP > max )
  1010.         num = max - MAX_DSP ;
  1011.     if( num < 0 )
  1012.         num = 0 ;
  1013.  
  1014.     if( rewrite != TRUE && ( dif = pos - num ) == 0 )
  1015.     {
  1016.         MOS_disp( mos_disp = TRUE ) ;
  1017.         return ;
  1018.     }
  1019.  
  1020.     MOS_disp( FALSE ) ;
  1021.     EGB_color( egbwork, 1, 15 ) ;
  1022.  
  1023.     if( rewrite == TRUE || abs( dif ) > 5 )     /*  再表示  */
  1024.     {
  1025.         dsp_box( SCR_X1,SCR_Y1, SCR_X2,SCR_Y2, 15,15,15 ) ;
  1026.         st = 0 ;    ed = ( maxnum-num > MAX_DSP ) ? MAX_DSP : (maxnum-num) ;
  1027.     }
  1028.     else if( dif < 0 )
  1029.     {
  1030.         EGB_partScroll( egbwork, 1, 0, -(ITEM_Y_SIZ), (char *)¶ ) ;
  1031.         st = MAX_DSP-5 ;    ed = MAX_DSP ;
  1032.     }
  1033.     else if( dif > 0 )
  1034.     {
  1035.         EGB_partScroll( egbwork, 1, 0, ITEM_Y_SIZ, (char *)¶ ) ;
  1036.         st = 0 ;    ed = 5 ;
  1037.     }
  1038.     else
  1039.         st = 0, ed = 0 ;
  1040.  
  1041.     pos = num ;
  1042.  
  1043.     for( i = st ; i+num < maxnum && i < ed ; i ++ )
  1044.         dsp_item( i, &inf[i+num], FALSE ) ;
  1045.  
  1046.     dsp_bar( num ) ;
  1047.  
  1048.     MOS_disp( mos_disp ) ;
  1049. }
  1050.  
  1051. /*  アイテム１個を表示する  */
  1052.  
  1053. void    dsp_item( int num, INF *ip, int clear )
  1054. {
  1055.     int     x, y ;
  1056.  
  1057.     x = item_x( num ) ;
  1058.     y = item_y( num ) ;
  1059.  
  1060.     if( clear == TRUE )
  1061.         dsp_box( x-4,y-5, x+108,y+60, 15,15,15 ) ;
  1062.  
  1063.     dsp_ptn( x+36,y+21, (char *)&icon[ ip->icon_num ], 1 ) ;
  1064.     dsp_box( x,y+17, x+104,y+17, 1,1,1 ) ;
  1065.  
  1066.     ip->name[12] = '\0' ;
  1067.     wrt( center( (char *)ip->name, 12 ), writepage,x+4,y, COL_1,BAK_COL, 16 ) ;
  1068.  
  1069. #ifdef DISP_NUM
  1070.     sprintf( tmp, "%2d", pos+num+1 ) ;
  1071.     wrt( tmp, writepage, x+4,y+19+4, COL_1,BAK_COL, 8 ) ;
  1072. #endif
  1073.  
  1074.     if( mark[ pos+num ] == TRUE )
  1075.         dsp_mark( num, TRUE ) ;
  1076. }
  1077.  
  1078.  
  1079. /*  スクロール・バーを表示する  */
  1080.  
  1081. static  void    dsp_bar( int num )
  1082. {
  1083.     auto    int     sz, ps ;
  1084.     auto    int     x = BAR_X ;
  1085.     auto    int     y = BAR_Y ;
  1086.     static  char    *vol_ptn = NULL ;
  1087.     auto    int     max = ( maxnum + 4 ) / 5 * 5 ;
  1088.  
  1089.     if( maxnum == 0 )
  1090.     {
  1091.         sz = BAR_SIZ ;
  1092.         vol_size = ps = 0 ;
  1093.     }
  1094.     else
  1095.     {
  1096.         if( ( sz = BAR_SIZ * MAX_DSP / max ) > BAR_SIZ )
  1097.             sz = BAR_SIZ ;
  1098.         vol_size = ( BAR_SIZ - sz ) ;
  1099.         ps = BAR_SIZ * num / max ;
  1100.     }
  1101.  
  1102.     if( vol_ptn == NULL )
  1103.     {
  1104.         dsp_box( x, y, x+19, y+BAR_SIZ+5, 0,0,15 ) ;
  1105.         dsp_box( x+7, y+3, x+12, y+BAR_SIZ+2, 0,0,8 ) ;
  1106.         if( ( vol_ptn = (char *)malloc( 20*(BAR_SIZ+7)+16) ) != NULL )
  1107.         {
  1108.             DWORD(vol_ptn+0) = (int)vol_ptn + 16 ;
  1109.             WORD(vol_ptn+4) = getds() ;
  1110.             WORD(vol_ptn+6) = x ;
  1111.             WORD(vol_ptn+8) = y ;
  1112.             WORD(vol_ptn+10) = x+19 ;
  1113.             WORD(vol_ptn+12) = y+BAR_SIZ+5 ;
  1114.             EGB_getBlock( egbwork, vol_ptn ) ;
  1115.         }
  1116.     }
  1117.     else
  1118.         EGB_putBlock( egbwork, 0, vol_ptn ) ;
  1119.     dsp_box( x+3, y+ps+3, x+16, y+ps+sz+3, 0,0,15 ) ;
  1120. }
  1121.  
  1122. char    *center( char *str, int width )
  1123. {
  1124.     static  char    buf[ 128 ] ;
  1125.     auto    int     i, len, left ;
  1126.  
  1127.     left = ( width - ( len = strlen( str ) ) ) / 2 ;
  1128.     if( left*2 + len != width )
  1129.         left ++ ;
  1130.  
  1131.     for( i = 0 ; i < left ; i ++ )
  1132.         buf[ i ] = ' ' ;
  1133.     strcpy( &buf[ left ], (char *)str ) ;
  1134.  
  1135.     return( buf ) ;
  1136. }
  1137.  
  1138.  
  1139. /*  TMENU.ICN ファイルを読み込む  */
  1140.  
  1141. void    readicon( char *path )
  1142. {
  1143.     auto    FILE    *fp ;
  1144.     auto    long    fsize ;
  1145.     auto    int     comp = FALSE ;
  1146.     REGS    int     i, j ;
  1147.  
  1148.     /*  読み込み  */
  1149.     if( ( fp = fopen( path, "rb" ) ) != NULL )
  1150.     {
  1151.         if( (u_int)( fsize = get_fsize( fp ) ) == sizeof( icon ) )
  1152.         {
  1153.             fread( icon, 1, sizeof( icon ), fp ) ;
  1154.             comp = TRUE ;
  1155.         }
  1156.         fclose( fp ) ;
  1157.     }
  1158.  
  1159.     if( comp != TRUE )                  /*  読み込み失敗  */
  1160.         for( i = 0 ; i < 128 ; i ++ )
  1161.             for( j = 0 ; j < 128 ; j ++ )
  1162.                 icon[i].pat[j] = 0xFF ;
  1163. }
  1164.  
  1165.  
  1166. /*
  1167.  *  .inf を読み込む
  1168.  
  1169.  *  戻り値
  1170.  *    ERR_NOERROR: エラーなし
  1171.  *    ERR_ABORT:   バッファ破壊後のエラー
  1172.  *    ERR_BREAK:   バッファ破壊前のエラー
  1173. */
  1174.  
  1175. int     readinf( char *path )
  1176. {
  1177.     auto    FILE    *fp ;
  1178.     auto    INF     *ip ;
  1179.     auto    long    fsize ;
  1180.     auto    int     i ;
  1181.  
  1182.     readicon( "\\tmenu.icn" ) ; /*  アイコン読み込み  */
  1183.     load_count ++ ;
  1184.  
  1185.     /*  読み込む  */
  1186.     if( ( fp = fopen( path, "rb" ) ) == NULL )
  1187.     {
  1188.         msg[0] = "ファイルがオープンできません" ;
  1189.         sprintf( tmp, "(%s)", path ) ;
  1190.         msg[1] = tmp ;
  1191.         msg[2] = NULL ;
  1192.         select_mode( msg_error, msg, msg_btn1 ) ;
  1193.  
  1194.         return ERR_BREAK ;
  1195.     }
  1196.     fsize = get_fsize( fp ) ;
  1197.     if( fsize % sizeof( INF ) != 0 ||
  1198.         ( maxnum = fsize / INFBUFSIZ ) > MAX_INF )
  1199.     {
  1200.         fclose( fp ) ;
  1201.  
  1202.         msg[0] = "ファイルの形式がおかしい" ;
  1203.         msg[1] = NULL ;
  1204.         select_mode( msg_error, msg, msg_btn1 ) ;
  1205.  
  1206.         return ERR_BREAK ;
  1207.     }
  1208.     if( fread( &inf, 1, fsize, fp ) != fsize )
  1209.     {
  1210.         fclose( fp ) ;
  1211.  
  1212.         msg[0] = "ファイルを正常に読めませんでした" ;
  1213.         msg[1] = NULL ;
  1214.         select_mode( msg_error, msg, msg_btn1 ) ;
  1215.  
  1216.         return ERR_ABORT ;
  1217.     }
  1218.     fclose( fp ) ;
  1219.  
  1220.     for( i = 0 ; i < maxnum ; i ++ )
  1221.     {
  1222.         ip = &inf[i] ;
  1223.  
  1224.         if( ( ip->dot != '.' && ip->dot != ' ' ) || ip->icon_num > 127 )
  1225.         {
  1226.             msg[0] = "不思議なデータが含まれています" ;
  1227.             msg[1] = NULL ;
  1228.             select_mode( msg_error, msg, msg_btn1 ) ;
  1229.  
  1230.             return ERR_ABORT ;
  1231.         }
  1232.     }
  1233.  
  1234.     /*  ここまできたら正常に読み込めた  */
  1235.  
  1236.     /*  ロード時のデータを覚えておく  */
  1237.     for( i = 0 ; i < maxnum ; i ++ )
  1238.         refresh_inf( &inf[i] ) ;
  1239.     memcpy( &org_inf[0], &inf[0], maxnum*INFBUFSIZ ) ;
  1240.     org_maxnum = maxnum ;
  1241.  
  1242.     /*  マークをリセット  */
  1243.     for( i = 0 ; i < MAX_INF ; i ++ )
  1244.         mark[ i ] = FALSE ;
  1245.     marknum = 0 ;
  1246.  
  1247.     return ERR_NOERROR ;
  1248. }
  1249.  
  1250. /*
  1251.  *  .inf を書き込む
  1252.  
  1253.  *  戻り値
  1254.  *      正常に書き込んだ                    ERROR 以外
  1255.  *      なんらかの理由で書き込めなかった    ERROR
  1256. */
  1257.  
  1258. static  int     writeinf( char *path )
  1259. {
  1260.     auto    FILE    *fp ;
  1261.     auto    long    fsize, wsize ;
  1262.     auto    int     ret_value = ERROR ;
  1263.     auto    char    *title = "データのセーブ" ;
  1264.     auto    int     i ;
  1265.  
  1266.     chg_palette( 0, now_palet = 1 ) ;
  1267.  
  1268.     /*  上書き確認  */
  1269.     if( ( fp = fopen( path, "rb" ) ) != NULL )
  1270.     {
  1271.         fclose( fp ) ;
  1272.         msg[0] = "データを上書きします。よろしいですか？" ;
  1273.         msg[1] = path ;
  1274.         msg[2] = NULL ;
  1275.         if( select_mode( title, msg, msg_btn2 ) != 0 )
  1276.             return( ERROR ) ;
  1277.     }
  1278.  
  1279.     /*  値の整形  */
  1280.     for( i = 0 ; i < maxnum ; i ++ )
  1281.         refresh_inf( &inf[i] ) ;
  1282.     for( i = 0 ; i < maxnum ; i ++ )
  1283.         toupper_inf( &inf[i] ) ;
  1284.  
  1285.     /*  書き込む  */
  1286.     if( ( fp = fopen( path, "wb" ) ) == NULL )
  1287.     {
  1288.         msg[0] = "ファイルがオープンできません" ;
  1289.         sprintf( tmp, "(%s)", path ) ;
  1290.         msg[1] = tmp ;
  1291.         msg[2] = NULL ;
  1292.         select_mode( title, msg, msg_btn1 ) ;
  1293.     }
  1294.     else
  1295.     {
  1296.         fsize = (long)sizeof( INF ) * maxnum ;
  1297.  
  1298.         wsize = fwrite( &inf, 1, fsize, fp ) ;
  1299.         fclose( fp ) ;
  1300.  
  1301.         if( wsize != fsize )
  1302.         {
  1303.             msg[0] = "ファイルを正常に書き込めませんでした" ;
  1304.             msg[1] = NULL ;
  1305.             select_mode( title, msg, msg_btn1 ) ;
  1306.         }
  1307.         else
  1308.         {
  1309.             msg[0] = "書き込み完了しました" ;
  1310.             msg[1] = NULL ;
  1311.             assert( title, msg ) ;
  1312.             ret_value = ERROR + 1 ;
  1313.         }
  1314.     }
  1315.  
  1316.     /*  セーブしたので、ロード時のデータを書き換える  */
  1317.     if( ret_value != ERROR )
  1318.     {
  1319.         for( i = 0 ; i < maxnum ; i ++ )
  1320.             refresh_inf( &inf[i] ) ;
  1321.         memcpy( &org_inf[0], &inf[0], maxnum*INFBUFSIZ ) ;
  1322.         org_maxnum = maxnum ;
  1323.     }
  1324.  
  1325.     chg_palette( 0, now_palet = 0 ) ;
  1326.  
  1327.     return( ret_value ) ;
  1328. }
  1329.  
  1330.  
  1331. void    mos_ptn( int no )   /*  マウス・カーソルの切り換え  */
  1332. {
  1333.     static  int     mos_csr_ptn = -1 ;      /*  マウス・カーソルの番号  */
  1334.     auto    MOS     *mp = &mosptn[ no ] ;
  1335.  
  1336.     if( mos_csr_ptn != no )
  1337.     {
  1338.         MOS_type( 1, mp->x, mp->y, &mp->xsiz ) ;
  1339.         MOS_color( 0, 15 ) ;
  1340.         mos_csr_ptn = no ;
  1341.     }
  1342. }
  1343.  
  1344. /*  スクロール・バーのクリップ  */
  1345.  
  1346. static  void    MOVE_clip( REGS EVENT *ep, int x, int y, int sw )
  1347. {
  1348.     auto    int     dum ;
  1349.  
  1350.     dum = x, dum = sw ;     /*  意味なし。ワーニングを避けるため  */
  1351.  
  1352.     switch( ep->now )
  1353.     {
  1354.       case EVT_ON_MOS:
  1355.         mos_ptn( 1 ) ;
  1356.         break ;
  1357.  
  1358.       case EVT_CLIP_MOS:
  1359.         mos_ptn( 1 ) ;
  1360.         MOS_horizon( ep->x1+9, ep->x1+11 ) ;
  1361.         MOS_vertical( ep->y1, ep->y2 ) ;
  1362.         ep->now = EVT_REP_MOS ;
  1363.       case EVT_REP_MOS:
  1364.         if( vol_size > 0 )
  1365.             dsp_scrn( ( ( y - ep->y1 ) * maxnum / BAR_SIZ ) / 5 * 5, FALSE ) ;
  1366.         break ;
  1367.  
  1368.       case EVT_DOLACK_MOS:
  1369.         ep->now = EVT_NON ;
  1370.       case EVT_OFF_MOS:
  1371.       case EVT_MOVE_MOS:
  1372.       case EVT_SELECT_MOS:
  1373.         mos_ptn( 0 ) ;
  1374.         MOS_horizon ( MIN_HORIZON,  MAX_HORIZON  ) ;
  1375.         MOS_vertical( MIN_VERTICAL, MAX_VERTICAL ) ;
  1376.         break ;
  1377.     }
  1378. }
  1379.  
  1380.  
  1381. void    move( int func, int x, int y )
  1382. {
  1383.     static  int     last_x = 0, last_y = 0 ;
  1384.     static  char    ptn[ (120+7) * (72+1) * 4 / 8 ] ;   /*  移動アイテム  */
  1385.     static  int     last_func = MV_START ;
  1386.     static  struct
  1387.     {
  1388.         u_short x1,y1, x2,y2 ;
  1389.     } para ;
  1390.  
  1391.     switch( func )
  1392.     {
  1393.       case MV_START:        /*  開始  */
  1394.         MOS_disp( mos_disp = FALSE ) ;
  1395.         DSP_writePage( egbwork, 0 ) ;
  1396.         getputBlock( x-4,y-5, x+108,y+60, ptn, TRUE ) ;
  1397.         func = MV_END ;
  1398.         break ;
  1399.  
  1400.       case MV_RESTART:      /*  再開始  */
  1401.         MOS_disp( mos_disp = FALSE ) ;
  1402.         cls( 1, 0 ) ;
  1403.         EGB_displayStart( egbwork, 1, OFFSET,0 ) ;
  1404.         getputBlock( x-55,y-32, x+57,y+33, ptn, FALSE ) ;
  1405.         DSP_writePage( egbwork, 0 ) ;
  1406.         break ;
  1407.  
  1408.       case MV_END:
  1409.         cls( 1, 0 ) ;
  1410.         EGB_displayStart( egbwork, 1, 0,0 ) ;
  1411.         DSP_writePage( egbwork, 0 ) ;
  1412.         MOS_disp( mos_disp = TRUE ) ;
  1413.         break ;
  1414.  
  1415.       case MV_LOOP:
  1416.         if( last_func == MV_END )
  1417.             move( MV_RESTART, x,y ) ;
  1418.  
  1419.         if( last_x == x && last_y == y )
  1420.             break ;
  1421.  
  1422.         if( last_x < x )    { para.x1 = last_x-55 ; para.x2 = x+57 ; }
  1423.         else                { para.x1 = last_x+57 ; para.x2 = x-57 ; }
  1424.         if( last_y < y )    { para.y1 = last_y-32 ; para.y2 = y+33 ; }
  1425.         else                { para.y1 = last_y+33 ; para.y2 = y-32 ; }
  1426.  
  1427.         DSP_writePage( egbwork, 1 ) ;
  1428.         EGB_color( egbwork, 1, 0 ) ;
  1429.         EGB_partScroll( egbwork, 1, x-last_x, y-last_y, (char*)¶ ) ;
  1430.         DSP_writePage( egbwork, 0 ) ;
  1431.  
  1432.         break ;
  1433.     }
  1434.  
  1435.     last_func = func ;
  1436.     last_x = x ;    last_y = y ;
  1437. }
  1438.  
  1439.  
  1440. /*  アイテムのクリック  */
  1441.  
  1442. static  void    ITEM_clip( REGS EVENT *ep, int x, int y, int sw )
  1443. {
  1444.     auto    int     num ;
  1445.     sw = sw ;                   /*  意味なし。ワーニングを避けるため  */
  1446.  
  1447.     switch( ep->now )
  1448.     {
  1449.       case EVT_ON_MOS:
  1450.         if( item_move != -1 || item_copy != -1 ||
  1451.             ( marknum > 0 && func != FUNC_DEL ) )
  1452.             move( MV_LOOP, x+OFFSET,y ) ;
  1453.         else
  1454.         {       /*  マウスカーソルの形状  */
  1455.                  if( func == FUNC_MOVE ) num = 3 ;
  1456.             else if( func == FUNC_DEL  ) num = 4 ;
  1457.             else if( func == FUNC_CHG  ) num = 5 ;
  1458.             else if( func == FUNC_EDIT ) num = 6 ;
  1459.             else                         num = 1 ;
  1460.             mos_ptn( num ) ;
  1461.         }
  1462.         break ;
  1463.  
  1464.       case EVT_DLSEL_MOS:
  1465.       case EVT_CLIP_MOS:
  1466.         break ;
  1467.  
  1468.       case EVT_MOVE_MOS:
  1469.       case EVT_DOLACK_MOS:
  1470.         ep->now = EVT_NON ;
  1471.         goto off ;
  1472.  
  1473.       case EVT_SELECT_MOS:
  1474.         menu_event = 20 + ( x - ITEM_X ) / ITEM_X_SIZ +
  1475.                           ( ( y - ITEM_Y ) / ITEM_Y_SIZ ) * 5 ;
  1476.         if( func == FUNC_DEL )
  1477.             break ;
  1478.       case EVT_OFF_MOS:
  1479. off:
  1480.         move( MV_END, 0,0 ) ;
  1481.  
  1482.         mos_ptn( 0 ) ;
  1483.         MOS_disp( mos_disp = TRUE ) ;
  1484.  
  1485.         break ;
  1486.     }
  1487. }
  1488.  
  1489. static  void    item_rewrite( int src, int dest, int last_clear )
  1490. {
  1491.     REGS    int     i ;
  1492.  
  1493.     if( dest < src )
  1494.         i = src, src = dest, dest = i ;
  1495.     if( dest < pos || src > pos+MAX_DSP )
  1496.         return ;
  1497.     if( ( src -= pos ) < 0 )
  1498.         src = 0 ;
  1499.     if( ( dest -= pos ) >= MAX_DSP )
  1500.         dest = MAX_DSP - 1 ;
  1501.  
  1502.     for( i = src ; i <= dest && i+pos < maxnum ; i ++ )
  1503.         dsp_item( i, &inf[ i+pos ], TRUE ) ;
  1504.  
  1505.     if( last_clear && i < MAX_DSP )
  1506.     {
  1507.         int     xpos = item_x( i ) ;
  1508.         int     ypos = item_y( i ) ;
  1509.         dsp_box( xpos-4,ypos-5, xpos+108,ypos+60, 15,15,15 ) ;
  1510.     }
  1511. }
  1512.  
  1513. static  void    dsp_mark( int num, int sw )
  1514. {
  1515.     int     x = item_x( num ) ;
  1516.     int     y = item_y( num ) ;
  1517.     int     col = sw == TRUE ? 0 : 15 ;
  1518.  
  1519.     box( x-4,y-4, x+108,y+58, col, LINE_PTN, 0 ) ;
  1520. }
  1521.  
  1522.  
  1523. static  void    MENU_clip( REGS EVENT *ep, int x, int y, int sw )
  1524. {
  1525. #define TICK_LIMIT 2000
  1526.     static  int     tick = 0 ;
  1527.     auto    int     now ;
  1528.     auto    int     dum ;
  1529.  
  1530.     dum = x, dum = y, dum = sw ;    /*  意味なし。ワーニングを避けるため  */
  1531.     now = ep->now ;
  1532.  
  1533.     switch( now )
  1534.     {
  1535.       case EVT_ON_MOS:
  1536.         mos_ptn( 1 ) ;
  1537.         break ;
  1538.  
  1539.       case EVT_OFF_MOS:
  1540.         mos_ptn( 0 ) ;
  1541.         break ;
  1542.  
  1543.       case EVT_CLIP_MOS:
  1544.         mos_ptn( 1 ) ;
  1545.         DSP_clip_on( ep ) ;
  1546.         if( ep->rep != FALSE )
  1547.             ep->now = EVT_REP_MOS ;
  1548.         tick = 0 ;
  1549.         break ;
  1550.  
  1551.       case EVT_REP_MOS:
  1552.         if( ++tick > TICK_LIMIT )
  1553.         {
  1554.             menu_event = ep->no ;
  1555.             tick = 0 ;
  1556.         }
  1557.         break ;
  1558.  
  1559.       case EVT_DOLACK_MOS:
  1560.         ep->now = EVT_NON ;
  1561.       case EVT_MOVE_MOS:
  1562.         DSP_clip_off( ep ) ;
  1563.         mos_ptn( 0 ) ;
  1564.         break ;
  1565.  
  1566.       case EVT_SELECT_MOS:
  1567.         menu_event = ep->no ;
  1568.         DSP_clip_off( ep ) ;
  1569.         mos_ptn( 0 ) ;
  1570.         break ;
  1571.     }
  1572. }
  1573.  
  1574. /*  終了確認  */
  1575.  
  1576. int     end_assert( char *file )
  1577. {
  1578.     int     change = FALSE ;
  1579.     int     i, ret, bnum ;
  1580.     char    *p, *btn[MAX_BTN_MSG+1] ;
  1581.  
  1582.     for( bnum = 0 ; bnum < MULTI_BUF ; bnum ++ )
  1583.     {
  1584.         if( maxnum == 0 && org_maxnum == 0 )
  1585.             change = FALSE ;
  1586.         else if( maxnum != org_maxnum )
  1587.             change = TRUE ;
  1588.         else
  1589.         {
  1590.             for( i = 0 ; i < maxnum ; i ++ )
  1591.                 toupper_inf( &inf[i] ) ;
  1592.             for( i = 0 ; i < maxnum ; i ++ )
  1593.                 refresh_inf( &inf[i] ) ;
  1594.  
  1595.             for( i = 0 ; i < maxnum ; i ++ )
  1596.                 if( memcmp( &inf[i], &org_inf[i], INFBUFSIZ ) != 0 )
  1597.                 {
  1598.                     change = TRUE ;
  1599.                     break ;
  1600.                 }
  1601.         }
  1602.  
  1603.         chg_palette( 0, now_palet = 1 ) ;
  1604.  
  1605.         if( change != FALSE )
  1606.         {
  1607.             msg[0] = "変更したデータを保存していません" ;
  1608.             sprintf( tmp, "( %s )",
  1609.                         strlen( file ) > 0 ? file : "ファイル名未定" ) ;
  1610.             msg[1] = tmp ;
  1611.             msg[2] = "  このまま終了するとデータが失われます  " ;
  1612.             msg[3] = "どうしますか？" ;
  1613.             msg[4] = NULL ;
  1614.  
  1615.             btn[0] = "保存して終了", btn[1] = "放棄して終了",
  1616.             btn[2] = "終了しない",   btn[3] = NULL ;
  1617.  
  1618.             switch( select_mode( "！ 警  告 ！", msg, btn ) )
  1619.             {
  1620.               case 0:
  1621.                 if( ( p = save_file( file ) ) == NULL )
  1622.                 {
  1623.                     chg_palette( 0, now_palet = 0 ) ;
  1624.                     return FALSE ;
  1625.                 }
  1626.                 else
  1627.                     strcpy( file, p ) ;
  1628.                 break ;
  1629.  
  1630.               case 1:       /*  強制終了  */
  1631.                 break ;
  1632.  
  1633.               case 2:
  1634.                 chg_palette( 0, now_palet = 0 ) ;
  1635.                 return FALSE ;
  1636.             }
  1637.         }
  1638.         strcpy( file, change_buf( file ) ) ;
  1639.     }
  1640.  
  1641.  
  1642.     chg_palette( 0, now_palet = 1 ) ;
  1643.  
  1644.     msg[0] = "終了します。よろしいですか？", msg[1] = NULL ;
  1645.  
  1646.     btn[0] = "終  了", btn[1] = "中  止", btn[2] = NULL ;
  1647.  
  1648.     ret = select_mode( msg_kakunin, msg, btn ) == 0 ? TRUE : FALSE ;
  1649.  
  1650.     chg_palette( 0, now_palet = 0 ) ;
  1651.  
  1652.     return ret ;
  1653. }
  1654.  
  1655.